home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Pascal / Libraries / WASTE 1.1a4 / WASTE Source / Assembly / Arrays.c next >
Encoding:
Text File  |  1994-03-13  |  2.6 KB  |  102 lines  |  [TEXT/KAHL]
  1. /*
  2.  *    Arrays.c
  3.  *
  4.  *    WASTE PROJECT
  5.  *    Utilities for handling handle-based dynamic arrays
  6.  *
  7.  *    Copyright (c) 1993-1994 Marco Piovanelli
  8.  *    All Rights Reserved
  9.  *
  10.  */
  11.  
  12. pascal OSErr _WEInsertSlot(Handle h, void *element, long insertAt, long slotSize);
  13. pascal OSErr _WERemoveSlot(Handle h, long removeAt, long slotSize);
  14.  
  15. #define    _BlockMoveData    dc.w 0xA22E
  16.  
  17. pascal OSErr _WEInsertSlot(Handle h, void *element, long insertAt, long slotSize)
  18. {
  19.     asm {
  20.             movem.l d3-d5, -(sp)            ; 
  21.             move.l slotSize, d3                ; d3 = slotSize
  22.             movea.l h, a0                    ; 
  23.             _GetHandleSize                    ; 
  24.             move.l d0, d4                    ; d4 = handle size
  25.             add.l d3, d0                    ; 
  26.             _SetHandleSize                    ; add one "slot"
  27.             bne.s @exit                    ; 
  28.             subq.w #8, sp                    ; reserve space for 64-bit result
  29.             move.l insertAt, -(sp)            ; 
  30.             move.l d3, -(sp)                ; 
  31.             pea 8(sp)                        ; 
  32.             _LongMul                        ; 
  33.             addq.w #4, sp                    ; throw away high long
  34.             move.l (sp)+, d5                ; offset = insertAt * slotSize
  35.             
  36.             moveq #-50, d0                ; check for a paramErr (-50)
  37.             tst.l d5                        ; offset < 0 ?
  38.             slt d1                        ; 
  39.             cmp.l d4, d5                    ; offset > handle size ?
  40.             sgt d2                        ; 
  41.             or.b d1, d2                    ; 
  42.             bne.s @exit                    ; 
  43.             
  44.             movea.l h, a0                    ; 
  45.             movea.l (a0), a0                ; 
  46.             adda.l d5, a0                    ; a0 = *h + offset
  47.             movea.l a0, a1                    ; 
  48.             adda.l d3, a1                    ; a1 = a0 + slotSize
  49.             move.l d4, d0                    ; 
  50.             sub.l d5, d0                    ; d0 = hSize - offset
  51.             _BlockMoveData                ; make room for new element
  52.             
  53.             movea.l a0, a1                    ; 
  54.             movea.l element, a0                ; 
  55.             move.l d3, d0                    ; 
  56.             _BlockMoveData                ; insert new element
  57.             
  58. @exit        movem.l (sp)+, d3-d5
  59.     }
  60. }
  61.  
  62. pascal OSErr _WERemoveSlot(Handle h, long removeAt, long slotSize)
  63. {
  64.     asm {
  65.             movem.l d3-d5, -(sp)            ; 
  66.             move.l slotSize, d3                ; d3 = slotSize
  67.             movea.l h, a0                    ; 
  68.             _GetHandleSize                    ; 
  69.             move.l d0, d4                    ; 
  70.             sub.l d3, d4                    ; d4 = hSize - slotSize
  71.             subq.w #8, sp                    ; reserve space for 64-bit result
  72.             move.l removeAt, -(sp)            ; 
  73.             move.l d3, -(sp)                ; 
  74.             pea 8(sp)                        ; 
  75.             _LongMul                        ; 
  76.             addq.w #4, sp                    ; throw away high long
  77.             move.l (sp)+, d5                ; offset = removeAt * slotSize
  78.             
  79.             moveq #-50, d0                ; check for a paramErr (-50)
  80.             tst.l d5                        ; offset < 0 ?
  81.             slt d1                        ; 
  82.             cmp.l d4, d5                    ; offset > (hSize - slotSize) ?
  83.             sgt d2                        ; 
  84.             or.b d1, d2                    ; 
  85.             bne.s @exit                    ; 
  86.             
  87.             movea.l h, a1                    ; 
  88.             movea.l (a1), a1                ; 
  89.             adda.l d5, a1                    ; 
  90.             movea.l a1, a0                    ; 
  91.             adda.l d3, a0                    ; 
  92.             move.l d4, d0                    ; 
  93.             sub.l d5, d0                    ; 
  94.             _BlockMoveData                ; compact the array
  95.             
  96.             movea.l h, a0                    ; 
  97.             move.l d4, d0                    ; 
  98.             _SetHandleSize                    ; remove unused space
  99.             
  100. @exit        movem.l (sp)+, d3-d5            ; 
  101.     }
  102. }